package com.aaa.product.controller;

import com.aaa.product.entity.SeckillStatus;
import com.aaa.product.entity.TbActProduct;
import com.aaa.product.entity.TbOrdInf;
import com.aaa.product.entity.TbPrdInfo;
import com.aaa.product.service.impl.SeckKillServiceImpl;
import com.aaa.product.service.impl.TbOrdInfServiceImpl;
import com.aaa.product.service.impl.TbOrdInfServiceImpl;
import com.aaa.product.task.MultiThreadingCreateOrder;
import com.aaa.product.util.DateUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

//import com.aaa.order.util.ConnUtil;

@RestController
@RequestMapping("order")
public class TbOrdInfController {

    @Resource
    TbOrdInfServiceImpl tbOrdInfServiceImpl;
    @Resource
    MultiThreadingCreateOrder multiThreadingCreateOrder;
    @Resource
    RedisTemplate redisTemplate;
    @Resource
    SeckKillServiceImpl seckKillService;


    @RequestMapping("selectAll")
    public List<TbOrdInf> selectAll(){
        return tbOrdInfServiceImpl.listDesc();
    }

    /*根据用户查全部订单*/
    @RequestMapping("findByTbid")
    public List<TbOrdInf> findByTbid(String accountId,Integer status,String lableName){
        return tbOrdInfServiceImpl.findByTbid(accountId,status,lableName);
    }

    @RequestMapping("saveOrUpdate")
    public boolean saveOrUpdate(TbOrdInf tbOrdInf){
        Date date = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = formatter.format(date);
        tbOrdInf.setUpdateDate(dateString);

        boolean b = tbOrdInfServiceImpl.saveOrUpdate(tbOrdInf);

        return b;
    }
    @RequestMapping("saveOrUpdate1")
    public String saveOrUpdate1(TbOrdInf tbOrdInf) throws IOException, TimeoutException {
        Date date = new Date();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = formatter.format(date);
        tbOrdInf.setUpdateDate(dateString);

        boolean b = tbOrdInfServiceImpl.saveOrUpdate(tbOrdInf);
        String oid = "";
        if (b){
//            Connection conn = ConnUtil.getConn();
//            //创建信道:处理消息
//            Channel channel = conn.createChannel();
//
//            String queueName = "my-que";
//            /**
//             * queueDeclare(String queue,队列名
//             *              boolean durable,持久化,当RabbitMQ关闭后消息依然存在
//             *              boolean exclusive,是否排外,证明这个消息一次只能被一个消费者使用
//             *              boolean autoDelete,是否自动删除,消息队列中被使用过的消息是否自动删除
//             *              Map<String, Object> arguments队列的其他属性信息,如队列的类型,队列的属性信息等
//             *              )
//             */
//            //创建队列
//            channel.queueDeclare(queueName,false,false,false,null);
//            //定义消息
//            String message = oid + System.currentTimeMillis();
//            // 设置延时属性
//            AMQP.BasicProperties.Builder builder = new AMQP.BasicProperties.Builder();
//            // 持久性 non-persistent (1) or persistent (2)
//            AMQP.BasicProperties properties = builder.expiration("60000").deliveryMode(2).build();
//            //basicPublish(交换器,序列名,参数信息,消息)   发送消息
//            channel.basicPublish("",queueName,null,message.getBytes());
//            //发送完成,关闭信道,关闭连接
//            channel.close();
//            conn.close();
            oid = tbOrdInf.getOid();
        }
        return oid;
    }
//    @RequestMapping("pay")
//    public boolean pay(String oid) throws IOException, TimeoutException {
//        Connection conn = ConnUtil.getConn();
//
//        //创建信道
//        Channel channel = conn.createChannel();
//
//        //队列名
//        String queueName = "my-que";
//        channel.queueDeclare(queueName,false,false,false,null);
//
//        //消费者
//        DefaultConsumer consumer = new DefaultConsumer(channel){
//            /**
//             * 应答的处理器:当消费者获取从队列中获取到消息时的回调函数,进行消费
//             * @param consumerTag 消费者表示
//             * @param envelope
//             * @param properties 参数信息
//             * @param body 消息内容
//             * @throws IOException
//             */
//            @Override
//            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//                System.out.println("前台oid"+oid);
//                System.out.println("consumerTag:"+consumerTag);
//                // 应答标识
//                System.out.println("deliveryTag:"+envelope.getDeliveryTag());
//                System.out.println("envelope:"+envelope.getExchange());
//                System.out.println("获取到的消息内容:"+new String(body));
//            }
//        };
//
//        // 消费者监听队列
//        // basicConsume(队列名,是否立即应答,消费者)
//        //5、监听队列
//        // true:表示自动确认，只要消息从队列中获取，无论消费者获取到消息后是否成功消费，都会认为 消息已经成功消费
//        // false:表示手动确认，消费者获取消息后，服务器会将该消息标记为不可用状态，等待消费者的 反馈， 如果消费者一直没有反馈，那么该消息将一直处于不可用状态，并且服务器会认为该消 费者已经挂掉，不会再给其 发送消息，直到该消费者反馈。
//        // */
//        channel.basicConsume(queueName,true,consumer);
//        channel.close();;
//        conn.close();
//        return true;
//    }
    @RequestMapping("delete")
    public boolean delete(Integer id){
        return tbOrdInfServiceImpl.removeById(id);
    }

    @RequestMapping("findById/{tid}")
    public TbOrdInf findById(@PathVariable String tid){
        return tbOrdInfServiceImpl.findById(tid);
    }

    @RequestMapping("findByOid")
    public TbOrdInf findByOid(String oid){
        TbOrdInf byOid = tbOrdInfServiceImpl.findByOid(oid);
        return byOid;
    }

    //模糊查询
    @RequestMapping("listBySname")
    public List<TbOrdInf> listByLname(String shippingName){
        return tbOrdInfServiceImpl.listBySname(shippingName);
    }


//    /**
////     *  秒杀下单 排队
////     * @param tbOrdInf
////     * @return
////     * @throws IOException
////     * @throws TimeoutException
////     */
////    @RequestMapping("saveOrUpdate2")
////    public Object saveOrUpdate2(TbOrdInf tbOrdInf)  {
////        System.out.println("Invoking an asynchronous method. " + Thread.currentThread().getName());
////        Future<Object> future = multiThreadingCreateOrder.createOrder(tbOrdInf);
////        while (true) { ///这里使用了循环判断，等待获取结果信息
////            if (future.isDone()) { //判断是否执行完毕
////                try {
////                    System.out.println("Result from asynchronous process - " + future.get());
////                    Object o = future.get();
////                    return o;
////                } catch (InterruptedException e) {
////                    e.printStackTrace();
////                } catch (ExecutionException e) {
////                    e.printStackTrace();
////                }
////                break;
////            }
////        }
////        return null;
////    }
//    /**
//     *  秒杀下单 排队
//     * @param tbOrdInf
//     * @return
//     * @throws IOException
//     * @throws TimeoutException
//     */
//    @RequestMapping("saveOrUpdate2")
//    public Boolean saveOrUpdate2(TbOrdInf tbOrdInf)  {
//        // 记录用户排队的次数
//        Long userQueueCount = redisTemplate.boundHashOps("UserQueueCount").increment(tbOrdInf.getAccountId(), 1);
//        if(userQueueCount > 1){
//            return false;
//        }
//
//
//        // 创建排队对象
//        SeckillStatus seckillStatus = new SeckillStatus(tbOrdInf,tbOrdInf.getAccountId(),1,tbOrdInf.getTid(),null);
//        // list 是队列类型, 用户抢单排队
//        redisTemplate.boundListOps("SeckillOrderQueue").leftPush(seckillStatus);
//        // 一个用户只能有一个排队状态 ,抢单
//        redisTemplate.boundHashOps("UserQueueStatus").put(tbOrdInf.getAccountId(),seckillStatus);
//
//        multiThreadingCreateOrder.createOrder();
//        return true;
//    }
    /**
     *  秒杀下单 排队
     * @param tbOrdInf
     * @return
     * @throws IOException
     * @throws TimeoutException
     */
    @RequestMapping("saveOrUpdate2")
    public void saveOrUpdate2(TbOrdInf tbOrdInf)  {
        redisTemplate.opsForValue().set("stockCount",null);
        String json = JSON.toJSONString(tbOrdInf);
        seckKillService.getShopByType(json);
        // 记录用户排队的次数
//        Long userQueueCount = redisTemplate.boundHashOps("UserQueueCount").increment(tbOrdInf.getAccountId(), 1);
//        if(userQueueCount > 1){
//            return false;
//        }
        // 创建排队对象
//        SeckillStatus seckillStatus = new SeckillStatus(tbOrdInf,tbOrdInf.getAccountId(),1,tbOrdInf.getTid(),null);
//        // list 是队列类型, 用户抢单排队
//        redisTemplate.boundListOps("SeckillOrderQueue").leftPush(seckillStatus);
//        // 一个用户只能有一个排队状态 ,抢单
//        redisTemplate.boundHashOps("UserQueueStatus").put(tbOrdInf.getAccountId(),seckillStatus);
//
//        multiThreadingCreateOrder.createOrder();
//        return true;
    }



}
